diff --git a/user_guide/tutorial/introduction.html b/user_guide/tutorial/introduction.html
index cb91f48..78fd00b 100644
--- a/user_guide/tutorial/introduction.html
+++ b/user_guide/tutorial/introduction.html
@@ -28,7 +28,7 @@
 <div id="masthead">
 <table cellpadding="0" cellspacing="0" border="0" style="width:100%">
 <tr>
-<td><h1>CodeIgniter User Guide Version 2.0.2</h1></td>
+<td><h1>CodeIgniter User Guide Version 2.0.3</h1></td>
 <td id="breadcrumb_right"><a href="../toc.html">Table of Contents Page</a></td>
 </tr>
 </table>
@@ -59,9 +59,7 @@
 
 <h1>Tutorial &minus; Introduction</h1>
 
-<p>This tutorial is intended to introduce you to the CodeIgniter framework and the basic principles of MVC architecture.
-    It will show you how a basic CodeIgniter application is constructed in step-by-step fashion.
-</p> 
+<p>This tutorial is intended to introduce you to the CodeIgniter framework and the basic principles of MVC architecture. It will show you how a basic CodeIgniter application is constructed in step-by-step fashion.</p> 
 
 <p>In this tutorial, you will be creating a <strong>basic news application</strong>. You will begin by writing the code that can load static pages. Next, you will create a news section that reads news items from a database. Finally, you'll add a form to create news items in the database.</p>
 
@@ -73,6 +71,17 @@
 <li>Performing basic database queries using &quot;Active Record&quot;</li>
 </ul>
 
+<p>The entire tutorial is split up over several pages, each explaining a small part of the functionality of the CodeIgniter framework. You'll go through the following pages:</p>
+<ul>
+<li>Introduction, this page, which gives you an overview of what to expect.</li>
+<li><a href="static_pages.html">Static pages</a>, which will teach you the basics of controllers, views and routing.</li>
+<li><a href="news_section.html">News section</a>, where you'll start using models and will be doing some basic database operations.</li>
+<li><a href="create_news_items.html">Create news items</a>, which will introduce more advanced database operations and form validation.</li>
+<li><a href="conclusion.html">Conclusion</a>, which will give you some pointers on further reading and other resources.</li>
+</ul>
+
+<p>Enjoy your exploration of the CodeIgniter framework.</p>
+
 </div>
 <!-- END CONTENT -->
 
